{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# 8.3 基于自注意力模型的文本语义匹配\n",
    "\n",
    "**文本语义匹配** {Text Semantic Matching}是一个十分常见的自然语言处理任务。比如在信息检索、问答系统，文本蕴含等任务中都需要用于文本语义匹配的技术。\n",
    "\n",
    "比如下面三个句子，句子A和句子C的语义更相似，但是如果通过字符串匹配的方式，A和B更容易被判断为相似。\n",
    "\n",
    "```\n",
    "A. 什么花一年四季都开？\n",
    "B. 什么花生一年四季都开？\n",
    "C. 哪些花可以全年开放？\n",
    "```\n",
    "\n",
    "文本语义匹配任务就是希望能从语义上更准确第判断两个句子之间的关系，而不是仅仅通过字符串匹配。\n",
    "令1表示“相似”，0表示“不相似”，我们希望文本语义匹配模型能够达到这样的效果：\n",
    "输入A和B两句话，输出为0,；输入A和C两句话，输出为1。\n",
    "\n",
    "本实践基于自注意力机制来进行文本语义匹配任务。和前两节不同，这里只是用自注意力模型，而不是将自注意力模型叠加在LSTM模型的上面。\n",
    "这里使用一个非常流行的网络结构Transformer。由于语义匹配是一个分类任务，因此只需要用到Transformer模型的编码器。\n",
    "\n",
    "基于Transformer编码器的文本语义匹配的整个模型结构如图所示：\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "<center><img src=\"https://ai-studio-static-online.cdn.bcebos.com/1b81fa33279a430a972cb30fb5b91143bcd2275f5931437a917a28e0a0e80c88\" width=\"700px\"></center>\n",
    "\n",
    "<br><center>图8.15 基于Transformer编码器的文本语义匹配模型结构</center></br>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "我们首先将两个句子“什么花一年四季都开”“哪些花可以全年开放”进行拼接，构建“[CLS]什么花一年四季都开[SEP]哪些花可以全年开放[SEP]”一个句子，其中“[CLS]”表示整个句子的特征，“[SEP]”表示两个句子的分割。这样我们可以将两个句子的匹配问题转换为一个句子的分类问题。\n",
    "\n",
    "然后，我们将合并后的句子转换成稠密的特征向量（图中的输入编码），然后加入对应的位置编码和分段编码，位置编码和分段编码也是稠密的特征向量，然后输入编码，位置编码分段编码按照位置相加，最终得到每个字符级别的特征表示，字符级别的表示包含了语义信息（输入编码），当前字符的位置信息(位置编码)和句子的信息（分段编码）。然后经过编码器得到多头自注意力机制后的输出，然后取第0个位置的句子向量接入线性层进行分类，得到最终的分类结果\"相似\"。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## 8.3.1 数据准备\n",
    "\n",
    "LCQMC是百度知道领域的中文问题匹配数据集，该数据集是从不同领域的用户中提取出来。LCQMC的训练集的数量是\t238766条，验证集的大小是4401条，测试集的大小是4401条。其目录结构如下：\n",
    "\n",
    "```\n",
    "lcqmc\n",
    "├── dev.csv  # 验证集\n",
    "├── test.csv # 测试集\n",
    "└── train.tsv # 训练集\n",
    "```\n",
    "\n",
    "下面看一下其中的一条数据，数据有三部分组成，前两句是文本，表示的是两句话，第三部分是标签，其中1表示的是两文本是相似的，0表示的是两文本是不相似的：\n",
    "\n",
    "```\n",
    "什么花一年四季都开      什么花一年四季都是开的  1\n",
    "```\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### 8.3.1.1  数据加载\n",
    "\n",
    "首先加载数据和词表，利用词表是把句子中的每个中文字符转换成ID。注意由于数据集不同，这里使用的词表跟上面文本分类实验里面的的词表不同。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from utils.data import load_vocab,load_lcqmc_data\n",
    "# 加载训练集，验证集，测试集\n",
    "train_data, dev_data, test_data=load_lcqmc_data('lcqmc')\n",
    "# 加载词表\n",
    "word2id_dict = load_vocab()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### 8.3.1.2 构建DataSet\n",
    "\n",
    "构造一个LCQMCDataset类，LCQMCDataset继承paddle.io.DataSet类，可以逐个数据进行处理。\n",
    "\n",
    "LCQMCDataset的作用首先就是把文本根据词表转换成ID的形式，对于一个不在词汇表里面的字，默认会将该词用[UNK]代替，由于输入的是两句话，所以需要加入分隔符号[SEP]，并且在起始位置加入[CLS]占位符来表示语义级别的特征表示。\n",
    "\n",
    "\n",
    "比如对于前面的例子，我们转换成如下的形式：\n",
    "```\n",
    "[CLS]什么花一年四季都开[SEP]什么花一年四季都是开的[SEP]\n",
    "```\n",
    "\n",
    "然后根据词表将每个词转换成相应的ID表示input_ids。除了用分隔符号[SEP]外，对每个词分别加一维特征segment_ids=0,1来区分该词是来自于哪个句子。0表示该词是来自第一个句子；1表示该词是来自第二个句子。\n",
    "\n",
    "\n",
    "\n",
    "```\n",
    "[101, 784, 720, 5709, 671, 2399, 1724, 2108, 6963, 2458, 102, 784, 720, 5709, 671, 2399, 1724, 2108, 6963, 3221, 2458, 4638, 102]\n",
    "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from paddle.io import Dataset\n",
    "\n",
    "class LCQMCDataset(Dataset):\n",
    "    def __init__(self, data, word2id_dict):\n",
    "        # 词表\n",
    "        self.word2id_dict = word2id_dict\n",
    "        # 数据\n",
    "        self.examples = data\n",
    "        # ['CLS']的id，占位符\n",
    "        self.cls_id = self.word2id_dict['[CLS]']\n",
    "        # ['SEP']的id，句子的分隔\n",
    "        self.sep_id = self.word2id_dict['[SEP]']\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        # 返回单条样本\n",
    "        example = self.examples[idx]\n",
    "        text, segment, label = self.words_to_id(example)\n",
    "        return text, segment, label\n",
    "\n",
    "    def __len__(self):\n",
    "        # 返回样本的个数\n",
    "        return len(self.examples)\n",
    "\n",
    "    def words_to_id(self, example):\n",
    "        text_a, text_b, label = example\n",
    "        # text_a 转换成id的形式\n",
    "        input_ids_a = [self.word2id_dict[item] if item in self.word2id_dict else self.word2id_dict['[UNK]'] for item in text_a]\n",
    "        # text_b 转换成id的形式\n",
    "        input_ids_b = [self.word2id_dict[item] if item in self.word2id_dict else self.word2id_dict['[UNK]'] for item in text_b]\n",
    "        # 加入[CLS],[SEP]\n",
    "        input_ids = [self.cls_id]+ input_ids_a + [self.sep_id] + input_ids_b + [self.sep_id]\n",
    "        # 对句子text_a,text_b做id的区分，进行的分隔\n",
    "        segment_ids = [0]*(len(input_ids_a)+2)+[1]*(len(input_ids_b)+1)\n",
    "        return input_ids, segment_ids, int(label)\n",
    "\n",
    "    @property\n",
    "    def label_list(self):\n",
    "        # 0表示不相似，1表示相似\n",
    "        return ['0', '1']\n",
    "\n",
    "# 加载训练集\n",
    "train_dataset = LCQMCDataset(train_data,word2id_dict)\n",
    "# 加载验证集\n",
    "dev_dataset = LCQMCDataset(dev_data,word2id_dict)\n",
    "# 加载测试集\n",
    "test_dataset = LCQMCDataset(test_data,word2id_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "\n",
    "### 8.3.1.3 构建Dataloader\n",
    "\n",
    "构建DataLoader的目的是组装成小批量的数据，在组装小批量的数据之前，首先对文本数据转为ID表示，然后把数据用[PAD]进行对齐。这里我们将[PAD]的ID设为0，因此补齐操作就是把ID序列用0对齐到最大长度。\n",
    "\n",
    "对数据进行统一格式化后，使用DataLoader组装成小批次的数据迭代器。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[Tensor(shape=[32, 52], dtype=int64, place=CUDAPlace(0), stop_gradient=True,\n",
      "       [[101 , 1599, 3614, ..., 0   , 0   , 0   ],\n",
      "        [101 , 2769, 2797, ..., 0   , 0   , 0   ],\n",
      "        [101 , 1920, 2157, ..., 0   , 0   , 0   ],\n",
      "        ...,\n",
      "        [101 , 1453, 3345, ..., 0   , 0   , 0   ],\n",
      "        [101 , 3299, 1159, ..., 5023, 2521, 102 ],\n",
      "        [101 , 3118, 802 , ..., 0   , 0   , 0   ]]), Tensor(shape=[32, 52], dtype=int64, place=CUDAPlace(0), stop_gradient=True,\n",
      "       [[0, 0, 0, ..., 0, 0, 0],\n",
      "        [0, 0, 0, ..., 0, 0, 0],\n",
      "        [0, 0, 0, ..., 0, 0, 0],\n",
      "        ...,\n",
      "        [0, 0, 0, ..., 0, 0, 0],\n",
      "        [0, 0, 0, ..., 1, 1, 1],\n",
      "        [0, 0, 0, ..., 0, 0, 0]])], Tensor(shape=[32], dtype=int64, place=CUDAPlace(0), stop_gradient=True,\n",
      "       [1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 1,\n",
      "        0, 1, 0, 1, 1, 1, 0, 1])]\n"
     ]
    }
   ],
   "source": [
    "from paddle.io import DataLoader\n",
    "import paddle\n",
    "\n",
    "def collate_fn(batch_data, pad_val=0, max_seq_len=512):\n",
    "    input_ids, segment_ids, labels = [], [], []\n",
    "    max_len = 0\n",
    "    # print(batch_data)\n",
    "    for example in batch_data:\n",
    "        input_id, segment_id, label = example\n",
    "        # 对数据序列进行截断\n",
    "        input_ids.append(input_id[:max_seq_len])\n",
    "        segment_ids.append(segment_id[:max_seq_len])\n",
    "        labels.append(label)\n",
    "        # 保存序列最大长度\n",
    "        max_len = max(max_len, len(input_id))\n",
    "    # 对数据序列进行填充至最大长度\n",
    "    for i in range(len(labels)):\n",
    "        input_ids[i] = input_ids[i]+[pad_val] * (max_len - len(input_ids[i]))\n",
    "        segment_ids[i] = segment_ids[i]+[pad_val] * (max_len - len(segment_ids[i]))\n",
    "    return (\n",
    "        paddle.to_tensor(input_ids),\n",
    "        paddle.to_tensor(segment_ids),\n",
    "    ), paddle.to_tensor(labels)\n",
    "\n",
    "batch_size = 32\n",
    "# 构建训练集,验证集，测试集的dataloader\n",
    "train_loader = DataLoader(\n",
    "    train_dataset, batch_size=batch_size, collate_fn=collate_fn, shuffle=False\n",
    ")\n",
    "dev_loader = DataLoader(\n",
    "    dev_dataset, batch_size=batch_size, collate_fn=collate_fn, shuffle=False\n",
    ")\n",
    "test_loader = DataLoader(\n",
    "    test_dataset, batch_size=batch_size, collate_fn=collate_fn, shuffle=False\n",
    ")\n",
    "\n",
    "# 打印输出一条mini-batch的数据\n",
    "for idx, item in enumerate(train_loader):\n",
    "    if idx == 0:\n",
    "        print(item)\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "从上面的输出可以看到，第一个张量的形状是[32,52],其中分别是样本数量和句子长度。如果句子本身的长度不够52个字符，则会补0处理；第二个张量的输出的维度是[32,52]，表示的是句子的编码，可以看到两个句子被编码成了只包含0，1的向量；最后一个张量是标签的编码，维度是32，表示有32个标签，1表示的是该句子是相似的，0表示的是该句子是不相似的。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## 8.3.2  模型构建\n",
    "\n",
    "<center><img src=\"https://ai-studio-static-online.cdn.bcebos.com/9256f30d032045f2a1fec3c44bd4e7747e4d331a04774d05938db566896aee96\" width=\"700px\"></center>\n",
    "\n",
    "<br><center>图8.16 文本语义匹配模型结构</center></br>\n",
    "\n",
    "\n",
    "\n",
    "如图8.15所示，基于Transformer编码器的语义匹配模型由以下几个部分组成：\n",
    "\n",
    " 1） 嵌入层：用于输入的句子中的词语的向量化表示，由于语义匹配任务的输入是两句文本，所以需要分段编码对每个句子进行向量化表示，最后还需要对句子中词语的位置进行向量化表示，即位置编码。\n",
    " \n",
    " 2） Transformer组块：使用Transformer的编码组块来计算深层次的特征表示。\n",
    " \n",
    " 3） 线性层：输出层，得到该句子的分类。线性层的输入是第一个位置[CLS]的输出向量。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "\n",
    "### 8.3.2.1 嵌入层\n",
    "\n",
    "嵌入层是将输入的文字序列转换为向量序列。这里除了之前的词向量外，我们还需要引入两种编码。\n",
    "\n",
    "\n",
    "1） **位置编码**{Position Embeddings}：自注意力模块本身无法感知序列的输入顺序信息，即一个词对其它词的影响和它们之间的距离没有关系。因此，自注意力模块通常需要和卷积网络、循环网络一起组合使用。如果单独使用自注意力模块，就需要对其输入表示补充位置信息。位置编码主要是把字的位置信息向量化。\n",
    "\n",
    "2） **分段编码** {Segment Embeddings}：由于本实践中处理的输入序列是由两个句子拼接而成。为了区分每个词来自于哪个句子，对每个词增加一个0,1分段标记，表示该词是第0或1个句子。分段编码是将分段标记也向量化。\n",
    "\n",
    "下面我们分别介绍这几种编码。\n",
    "\n",
    "**（1）输入编码**\n",
    "\n",
    "**输入编码** {Input Embeddings}把输入的词转化成向量的形式。输入编码看作是一个查表的操作，对于每个单词，要将这些符号转换为向量形式．一种简单的转换方法是通过一个**嵌入表** {Embedding Lookup Table}来将每个符号直接映射成向量表示．这里使用飞桨的paddle.nn.Embedding来根据输入序列中的id信息从嵌入矩阵中查询对应嵌入向量。\n",
    "\n",
    "```\n",
    "class paddle.nn.Embedding(num_embeddings, embedding_dim, padding_idx=None, sparse=False, weight_attr=None, name=None)\n",
    "```\n",
    "\n",
    "`paddle.nn.Embedding`会根据`[num_embeddings, embedding_dim]`自动构造一个二维嵌入矩阵。如果配置了`padding_idx`，那么在训练过程中遇到此id时，其参数及对应的梯度将会以0进行填充。\n",
    "\n",
    "在Transformer的输入编码的实现中，初始化使用的是随机正态分布，均值为0，标准差为$\\frac{1}{\\sqrt{\\textrm{emb\\_size}}}$，$\\textrm{emb\\_size}$表示的是词向量的维度。所有的向量都乘以了$\\sqrt{\\textrm{emb\\_size}}$。代码实现如下：\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "W0714 14:06:33.794049   204 device_context.cc:447] Please NOTE: device: 0, GPU Compute Capability: 8.0, Driver API Version: 11.2, Runtime API Version: 11.2\n",
      "W0714 14:06:33.800398   204 device_context.cc:465] device: 0, cuDNN Version: 8.2.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "输入编码为： [1 0 2]\n",
      "输出为： [[-0.7112208  -0.35037443  0.7261958  -0.31876457]\n",
      " [ 0.          0.          0.          0.        ]\n",
      " [-0.43065292  0.35489145  1.9781216   0.12072387]]\n"
     ]
    }
   ],
   "source": [
    "import paddle\n",
    "import paddle.nn as nn\n",
    "\n",
    "class WordEmbedding(nn.Layer):\n",
    "    def __init__(self, vocab_size, emb_size, padding_idx=0):\n",
    "        super(WordEmbedding, self).__init__()\n",
    "        # Embedding的维度\n",
    "        self.emb_size = emb_size\n",
    "        # 使用随机正态（高斯）分布初始化 embedding\n",
    "        self.word_embedding = nn.Embedding(vocab_size, emb_size,\n",
    "            padding_idx=padding_idx, weight_attr=paddle.ParamAttr(\n",
    "                initializer=nn.initializer.Normal(0.0, emb_size ** -0.5) ), )\n",
    "\n",
    "    def forward(self, word):\n",
    "        word_emb = self.emb_size ** 0.5 * self.word_embedding(word)\n",
    "        return word_emb\n",
    "\n",
    "paddle.seed(2021)\n",
    "# 构造一个输入\n",
    "X = paddle.to_tensor([1, 0, 2])\n",
    "# 表示构造的输入编码的词汇表的大小是10，每个词的维度是4\n",
    "word_embed = WordEmbedding(10, 4)\n",
    "print(\"输入编码为： {}\".format(X.numpy()))\n",
    "word_out = word_embed(X)\n",
    "print(\"输出为： {}\".format(word_out.numpy()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "**（2）分段编码**\n",
    "\n",
    "分段编码的作用是使得模型能够接受句子对进行训练，用编码的方法使得模型能够区分两个句子。这里指定0来标记句子0，用1标记句子1。对于句子0，创建标记为0的向量，对于句子1，创建标记为1的向量。分段编码的实现跟输入编码类似，不同在于词表大小为2。\n",
    "\n",
    "以下面的句子为例，\n",
    "\n",
    "```\n",
    "什么花一年四季都开      什么花一年四季都是开的\n",
    "```\n",
    "我们的分段标记为：\n",
    "\n",
    "```\n",
    "0 0 0 0 0 0 0 0 0    1 1 1 1 1 1 1 1 1 1 1\n",
    "```\n",
    "\n",
    "下面我们实现分段编码，将分段标记映射为向量表示。分段编码的维度和输入编码一样。\n",
    "代码实现如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "输入编码为： [0 0 1 1]\n",
      "输出为： [[-0.90914416  0.7011595  -0.33276933  0.892782  ]\n",
      " [-0.90914416  0.7011595  -0.33276933  0.892782  ]\n",
      " [-0.52305263 -0.2739423   0.5322813  -0.25009495]\n",
      " [-0.52305263 -0.2739423   0.5322813  -0.25009495]]\n"
     ]
    }
   ],
   "source": [
    "class SegmentEmbedding(nn.Layer):\n",
    "    def __init__(self, vocab_size, emb_size):\n",
    "        super(SegmentEmbedding, self).__init__()\n",
    "        # Embedding的维度\n",
    "        self.emb_size = emb_size\n",
    "        # 分段编码\n",
    "        self.seg_embedding = nn.Embedding(\n",
    "            num_embeddings=vocab_size, embedding_dim=emb_size\n",
    "        )\n",
    "\n",
    "    def forward(self, word):\n",
    "        seg_embedding = self.seg_embedding(word)\n",
    "        return seg_embedding\n",
    "\n",
    "paddle.seed(2021)\n",
    "# 构造一个输入,0表示第0句的token，1表示第1句的token\n",
    "X = paddle.to_tensor([0, 0, 1, 1])\n",
    "word_embed = SegmentEmbedding(2, 4)\n",
    "print(\"输入编码为： {}\".format(X.numpy()))\n",
    "word_out = word_embed(X)\n",
    "print(\"输出为： {}\".format(word_out.numpy()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "**（3）位置编码**\n",
    "\n",
    "为了使得自注意力模块可以感知序列的顺序信息，Transformer给编码层输入添加了一个额外的位置编码。\n",
    "位置编码的目的是在让自注意力模块在计算时引入词之间的距离信息。\n",
    "\n",
    "下面我们用三角函数（正弦或者余弦）来编码位置信息。假设位置编码的维度为$D$，则其中每一维的值的计算如下：\n",
    "$$\n",
    "PE(pos,2i) =\\sin\\left(\\frac{t}{10000^{{2i/D}}}\\right),\\\\\n",
    "PE(pos,2i+1) =\\cos\\left(\\frac{t}{10000^{{2i/D}}}\\right),\n",
    "$$\n",
    "其中$t$是指当前词在句子中的位置，$0 \\leqslant i\\leqslant \\frac{D}{2}$为编码向量的维数。在偶数维，使用正弦编码；在奇数维，使用余弦编码。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "位置编码的输出为：[[ 0.          1.          0.        ]\n",
      " [ 0.84147096  0.5403023   0.00215443]\n",
      " [ 0.9092974  -0.41614684  0.00430886]\n",
      " [ 0.14112    -0.9899925   0.00646326]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import paddle\n",
    "\n",
    "# position_size 为句子划分成字符或者词的长度，hidden_size为词向量的维度。\n",
    "def get_sinusoid_encoding(position_size, hidden_size):\n",
    "    \"\"\"位置编码 \"\"\"\n",
    "\n",
    "    def cal_angle(pos, hidden_idx):\n",
    "        # 公式里的 i = hid_idx // 2\n",
    "        return pos / np.power(10000, 2 * (hidden_idx // 2) / hidden_size)\n",
    "\n",
    "    def get_posi_angle_vec(pos):\n",
    "        return [cal_angle(pos, hidden_j) for hidden_j in range(hidden_size)]\n",
    "\n",
    "    sinusoid = np.array([get_posi_angle_vec(pos_i) for pos_i in range(position_size)])\n",
    "    # dim 2i  偶数正弦\n",
    "    # 从0开始，每隔2间隔求正弦值\n",
    "    sinusoid[:, 0::2] = np.sin(sinusoid[:, 0::2])\n",
    "    # dim 2i 1  奇数余弦\n",
    "    # 从1开始，每隔2间隔取余弦\n",
    "    sinusoid[:, 1::2] = np.cos(sinusoid[:, 1::2])\n",
    "    # position_size × hidden_size  得到每一个词的位置向量\n",
    "    return sinusoid.astype(\"float32\")\n",
    "\n",
    "paddle.seed(2021)\n",
    "position_size = 4\n",
    "hidden_size = 3\n",
    "encoding_vec=get_sinusoid_encoding(position_size, hidden_size)\n",
    "print(\"位置编码的输出为：{}\".format(encoding_vec))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "利用上面的三角函数来实现位置编码，代码如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "输入向量为：[1 0 1]\n",
      "位置编码的输出为： [[8.4147096e-01 5.4030228e-01 2.5116222e-02 9.9968451e-01 6.3095731e-04]\n",
      " [0.0000000e+00 1.0000000e+00 0.0000000e+00 1.0000000e+00 0.0000000e+00]\n",
      " [8.4147096e-01 5.4030228e-01 2.5116222e-02 9.9968451e-01 6.3095731e-04]]\n"
     ]
    }
   ],
   "source": [
    "class PositionalEmbedding(nn.Layer):\n",
    "    def __init__(self, max_length,emb_size):\n",
    "        super(PositionalEmbedding, self).__init__()\n",
    "        self.emb_size = emb_size\n",
    "        # 使用三角函数初始化Embedding\n",
    "        self.pos_encoder = nn.Embedding(\n",
    "            num_embeddings=max_length,\n",
    "            embedding_dim=self.emb_size,\n",
    "            weight_attr=paddle.ParamAttr(\n",
    "                initializer=paddle.nn.initializer.Assign(\n",
    "                    get_sinusoid_encoding(max_length, self.emb_size))))\n",
    "    \n",
    "    def forward(self, pos):\n",
    "        pos_emb = self.pos_encoder(pos)\n",
    "        # 关闭位置编码的梯度更新\n",
    "        pos_emb.stop_gradient = True\n",
    "        return pos_emb\n",
    "\n",
    "paddle.seed(2021)\n",
    "out = paddle.randint(low=0, high=5, shape=[3])\n",
    "print('输入向量为：{}'.format(out.numpy()))\n",
    "pos_embed=PositionalEmbedding(4,5)\n",
    "pos_out=pos_embed(out)\n",
    "print('位置编码的输出为： {}'.format(pos_out.numpy()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "为了对使用三角函数的位置编码有个直观了解，这里对三角函数初始化的值进行可视化，代码如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def plot_curve(size,y):\n",
    "    plt.figure(figsize=(15, 5))\n",
    "    plt.plot(np.arange(size), y[0, :, 4:5].numpy(),color='#e4007f',linestyle='-')\n",
    "    plt.plot(np.arange(size), y[0, :, 5:6].numpy(),color='#f19ec2',linestyle='--')\n",
    "    plt.plot(np.arange(size), y[0, :, 6:7].numpy(),color='#000000',linestyle='-.')\n",
    "    plt.legend([\"dim %d\"%p for p in [4,5,6]], fontsize='large')\n",
    "    plt.savefig('att-vis2.pdf')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "model = PositionalEmbedding(emb_size=20, max_length=5000)\n",
    "# 生成0~99这100个数，表示0~99这100个位置\n",
    "size = 100\n",
    "X= paddle.arange((size)).reshape([1,size])\n",
    "# 对这100个位置进行编码，得到每个位置的向量表示\n",
    "# y: [1,100,20]\n",
    "y = model(X)\n",
    "# 把这100个位置的第4，5，6列的数据可视化出来\n",
    "plot_curve(size,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "可以看到，位置编码本质上是一个和位置相关的正弦曲线，每个维度的正弦波的频率和大小不一样，取值范围在$[-1,1]$之间。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "********\n",
    "基于三角函数的位置编码，计算任意两个位置的点积，观察是否可以推断出两个位置的距离信息？\n",
    "********"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "********\n",
    "总结基于三角函数的位置编码的优缺点，并思考更好的位置编码方式\n",
    "********"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "**（4）嵌入层汇总**\n",
    "\n",
    "最后，我们把输入编码，分段编码和位置编码进行相加，并对加和后的向量进行层规范化和暂退操作，代码如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "class TransformerEmbeddings(nn.Layer):\n",
    "    \"\"\"\n",
    "    包括输入编码，分段编码，位置编码\n",
    "    \"\"\"\n",
    "    def __init__(\n",
    "        self,\n",
    "        vocab_size,\n",
    "        hidden_size=768,\n",
    "        hidden_dropout_prob=0.1,\n",
    "        position_size=512,\n",
    "        segment_size=2,\n",
    "    ):\n",
    "        super(TransformerEmbeddings, self).__init__()\n",
    "        # 输入编码向量\n",
    "        self.word_embeddings = WordEmbedding(vocab_size, hidden_size)\n",
    "        # 位置编码向量\n",
    "        self.position_embeddings = PositionalEmbedding(position_size, hidden_size)\n",
    "        # 分段编码\n",
    "        self.segment_embeddings = SegmentEmbedding(segment_size, hidden_size)\n",
    "        # 层规范化\n",
    "        self.layer_norm = nn.LayerNorm(hidden_size)\n",
    "        # Dropout操作\n",
    "        self.dropout = nn.Dropout(hidden_dropout_prob)\n",
    "\n",
    "    def forward(self, input_ids, segment_ids = None, position_ids = None):\n",
    "        if position_ids is None:\n",
    "            # 初始化全1的向量，比如[1,1,1,1]\n",
    "            ones = paddle.ones_like(input_ids, dtype=\"int64\")\n",
    "            # 累加输入,求出序列前K个的长度,比如[1,2,3,4]\n",
    "            seq_length = paddle.cumsum(ones, axis=-1)\n",
    "            # position id的形式： 比如[0,1,2,3]\n",
    "            position_ids = seq_length - ones\n",
    "            position_ids.stop_gradient = True\n",
    "        # 输入编码\n",
    "        input_embedings = self.word_embeddings(input_ids)\n",
    "        # 分段编码\n",
    "        segment_embeddings = self.segment_embeddings(segment_ids)\n",
    "        # 位置编码\n",
    "        position_embeddings = self.position_embeddings(position_ids)\n",
    "        # 输入张量, 分段张量，位置张量进行叠加\n",
    "        embeddings = input_embedings + segment_embeddings + position_embeddings\n",
    "        # 层规范化\n",
    "        embeddings = self.layer_norm(embeddings)\n",
    "        # Dropout\n",
    "        embeddings = self.dropout(embeddings)\n",
    "        return embeddings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### 8.3.2.2 Transformer组块\n",
    "\n",
    "Transformer编码器由多个Transformer组块叠加而成。一个Transformer组块的结构如图8.17所示，共包含四个模块：多头注意力层、加与规范化层、前馈层、加与规范化层。\n",
    "\n",
    "<center><img src=\"https://ai-studio-static-online.cdn.bcebos.com/0ec699f6bdb04e7db58c18be2bbfd41d7b8def8ac9a847ccb7ca75b6726ed538\" width=\"500px\"></center>\n",
    "\n",
    "<br><center>图8.17 Transformer组块结构</center></br>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "下面我们分别实现这几个层。\n",
    "\n",
    "**多头自注意力层**\n",
    "\n",
    "多头自注意力直接使用在第8.2.1.3中定义的`MultiHeadSelfAttention`算子。\n",
    "\n",
    "**加与规范层**\n",
    "\n",
    "**加与规范**{Add\\&Norm}层主要功能是加入**残差连接**{Residual Connection}与**层规范化**{Layer Normalization}两个组件，使得网络可以更好地训练。残差连接有助于避免深度网络中的梯度消失问题，而层规范化保证数据特征分布的稳定性，网络的收敛性更好。\n",
    "\n",
    "在Transformer组块，有两个地方使用了加与规范层，这里是第一次使用。\n",
    "\n",
    "假设多头自注意力层的输入和输出分别为$\\mathbf X\\in \\mathbb{R}^{B \\times L \\times D}$和$\\mathbf H\\in \\mathbb{R}^{B \\times L \\times D}$，加与规范层可以写为\n",
    "$$\n",
    "\\mathbf H=\\mathrm{LN}(\\mathbf H+\\mathbf X),\n",
    "$$\n",
    "\n",
    "$\\mathrm{LN(\\cdot)}$表示层规范化操作。\n",
    "\n",
    "加与规范层的实现如下，这里还对$\\mathbf H$进行了Dropout操作。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import paddle.nn as nn\n",
    "\n",
    "class AddNorm(nn.Layer):\n",
    "    \"\"\"加与规范化\"\"\"\n",
    "    def __init__(self, size, dropout_rate):\n",
    "        super(AddNorm, self).__init__()\n",
    "        self.layer_norm = nn.LayerNorm(size)\n",
    "        self.dropout = nn.Dropout(dropout_rate)\n",
    "\n",
    "    def forward(self, X, H):\n",
    "        \"\"\"\n",
    "            X：表示被包裹的非线性层的输入\n",
    "            H：表示被包裹的非线性层的输出\n",
    "        \"\"\"\n",
    "        H = X + self.dropout(H)\n",
    "        return self.layer_norm(H)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "  在Transformer的具体实现中，层规范化操作的位置有两种，分别称为PreNorm和PostNorm。假设要给非线性$\\mathbf H=f(\\mathbf X)$加上加与规范层，则PreNorm和PostNorm分别定义为：\n",
    "$$\n",
    "  \\mathrm{PreNorm} : \\mathbf H=\\mathbf X + f(\\mathrm{LN}(\\mathbf X) ) \\\\\n",
    "  \\mathrm{PostNorm} : \\mathbf H=\\mathrm{LN} (f(\\mathbf X)+\\mathbf X))\n",
    "$$\n",
    "很多研究表明， PreNorm更容易训练，但PostNorm上限更佳。请分析其背后的原因。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "**逐位前馈层**\n",
    "\n",
    "逐位前馈层（Position-wised Feed Forward Networks，FFN）是两层全连接神经网络，使用ReLU激活函数。将每个位置的特征表示进行融合变换，类似于更复杂的核大小为1的“卷积”。\n",
    "\n",
    "假设逐位前馈层的输入为张量$\\mathbf H \\in \\mathbb{R}^{B \\times L \\times D}$，其中$B,L,D$分别表示输入张量的批量大小、序列长度和特征维度，则前馈层的计算公式为：\n",
    "$$\n",
    "\\mathrm{FNN}(\\mathbf H)=\\max(0,\\mathbf H\\mathbf W_1+\\mathbf b_1)\\mathbf W_2+\\mathbf b_2,\n",
    "$$\n",
    "其中$\\mathbf W_{1} \\in \\mathbb{R}^{ D \\times D'}$，$\\mathbf W_{2} \\in \\mathbb{R}^{D'\\times D}$，$\\mathbf b_{1} \\in \\mathbb{R}^{D'}$，$\\mathbf b_{2} \\in \\mathbb{R}^{D}$是可学习的参数，\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "逐位前馈层的代码实现如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "class PositionwiseFFN(nn.Layer):\n",
    "    \"\"\"逐位前馈层\"\"\"\n",
    "    def __init__(self, input_size, mid_size, dropout=0.1):\n",
    "        super(PositionwiseFFN, self).__init__()\n",
    "        self.W_1 = nn.Linear(input_size, mid_size)\n",
    "        self.W_2 = nn.Linear(mid_size, input_size)\n",
    "        self.dropout = nn.Dropout(dropout)\n",
    "\n",
    "    def forward(self, X):\n",
    "        return self.W_2(self.dropout(F.relu(self.W_1(X))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "**加与规范层**\n",
    "\n",
    "逐位前馈层之后是第二个加与规范层，实现和第8.3.2.2\n",
    "节中一样，这里就不再重复。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "**Transformer组块汇总**\n",
    "\n",
    "汇总上面的的4个模块，构建Transformer组块。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "class TransformerBlock(nn.Layer):\n",
    "    def __init__(\n",
    "        self,\n",
    "        input_size,\n",
    "        head_num,\n",
    "        ffn_size,\n",
    "        dropout=0.1,\n",
    "        attn_dropout=None,\n",
    "        act_dropout=None,\n",
    "    ):\n",
    "        super(TransformerBlock, self).__init__()\n",
    "        # 输入数据的维度\n",
    "        self.input_size = input_size\n",
    "        # 多头自注意力多头的个数\n",
    "        self.head_num = head_num\n",
    "        # 逐位前馈层的大小\n",
    "        self.ffn_size = ffn_size\n",
    "        # 加与规范化里面 Dropout的参数\n",
    "        self.dropout = dropout\n",
    "        # 多头注意力里面的 Dropout参数\n",
    "        self.attn_dropout = dropout if attn_dropout is None else attn_dropout\n",
    "        # 逐位前馈层里面的 Dropout参数\n",
    "        self.act_dropout = dropout if act_dropout is None else act_dropout\n",
    "        # 多头自注意力机制\n",
    "        self.multi_head_attention = nn.MultiHeadAttention(\n",
    "            self.input_size,\n",
    "            self.head_num,\n",
    "            dropout=self.attn_dropout,\n",
    "            need_weights=True,\n",
    "        )\n",
    "        # 逐位前馈层\n",
    "        self.ffn = PositionwiseFFN(self.input_size, self.ffn_size, self.act_dropout)\n",
    "        # 加与规范化\n",
    "        self.addnorm = AddNorm(self.input_size, self.dropout)\n",
    "\n",
    "    def forward(self, X, src_mask=None):\n",
    "        # 多头注意力\n",
    "        X_atten, atten_weights = self.multi_head_attention(X, attn_mask=src_mask)\n",
    "        # 加与规范化\n",
    "        X = self.addnorm(X, X_atten)\n",
    "        # 前馈层\n",
    "        X_ffn = self.ffn(X)\n",
    "        # 加与规范化\n",
    "        X = self.addnorm(X, X_ffn)\n",
    "        return X, atten_weights"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### 8.3.2.3 模型汇总\n",
    "\n",
    "接下来，我们将嵌入层、Transformer组件、线性输出层进行组合，构建Transformer模型。\n",
    "\n",
    "Transformer模型主要是输入编码，分段编码，位置编码，Transformer编码器和最后的全连接分类器，代码实现如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "class Model_Transformer(nn.Layer):\n",
    "    def __init__(\n",
    "        self,\n",
    "        vocab_size,\n",
    "        n_block=2,\n",
    "        hidden_size=768,\n",
    "        heads_num=12,\n",
    "        intermediate_size=3072,\n",
    "        hidden_dropout=0.1,\n",
    "        attention_dropout=0.1,\n",
    "        act_dropout=0,\n",
    "        position_size=512,\n",
    "        num_classes=2,\n",
    "        padding_idx=0,\n",
    "    ):\n",
    "        super(Model_Transformer, self).__init__()\n",
    "        # 词表大小\n",
    "        self.vocab_size = vocab_size\n",
    "        # Transformer的编码器的数目\n",
    "        self.n_block = n_block\n",
    "        # 每个词映射成稠密向量的维度\n",
    "        self.hidden_size = hidden_size\n",
    "        # 多头注意力的个数\n",
    "        self.heads_num = heads_num\n",
    "        # 逐位前馈层的的维度\n",
    "        self.intermediate_size = intermediate_size\n",
    "        # Embedding层的 Dropout\n",
    "        self.hidden_dropout = hidden_dropout\n",
    "        # 多头注意力的dropout的 dropout参数\n",
    "        self.attention_dropout = attention_dropout\n",
    "        # 位置编码的大小 position_size\n",
    "        self.position_size = position_size\n",
    "        # 类别数\n",
    "        self.num_classes = num_classes\n",
    "        # 逐位前馈层的dropout\n",
    "        self.act_dropout = act_dropout\n",
    "        # [PAD]字符的ID\n",
    "        self.padding_idx = padding_idx\n",
    "        # 实例化输入编码，分段编码和位置编码\n",
    "        self.embeddings = TransformerEmbeddings(\n",
    "            self.vocab_size, self.hidden_size, self.hidden_dropout, self.position_size )\n",
    "        # 实例化Transformer的编码器\n",
    "        self.layers = nn.LayerList([])\n",
    "        for i in range(n_block):\n",
    "            encoder_layer = TransformerBlock(\n",
    "                hidden_size,\n",
    "                heads_num,\n",
    "                intermediate_size,\n",
    "                dropout=hidden_dropout,\n",
    "                attn_dropout=attention_dropout,\n",
    "                act_dropout=act_dropout,\n",
    "            )\n",
    "            self.layers.append(encoder_layer)\n",
    "        # 全连接层\n",
    "        self.dense = nn.Linear(hidden_size, hidden_size)\n",
    "        # 双曲正切激活函数\n",
    "        self.activation = nn.Tanh()\n",
    "        # 最后一层分类器\n",
    "        self.classifier = nn.Linear(hidden_size, num_classes)\n",
    "\n",
    "    def forward(self, inputs, position_ids=None, attention_mask=None):\n",
    "        input_ids, segment_ids = inputs\n",
    "        # 构建Mask矩阵，把Pad的位置即input_ids中为0的位置设置为True,非0的位置设置为False\n",
    "        if attention_mask is None:\n",
    "            attention_mask = paddle.unsqueeze(\n",
    "                (input_ids == self.padding_idx).astype(\"float32\") * -1e9, axis=[1, 2] )\n",
    "        # 抽取特征向量\n",
    "        embedding_output = self.embeddings(\n",
    "            input_ids=input_ids, position_ids=position_ids, segment_ids=segment_ids )\n",
    "        sequence_output = embedding_output\n",
    "        self._attention_weights = []\n",
    "        # Transformer的输出和注意力权重的输出\n",
    "        for i, encoder_layer in enumerate(self.layers):\n",
    "            sequence_output, atten_weights = encoder_layer(\n",
    "                sequence_output, src_mask=attention_mask )\n",
    "            self._attention_weights.append(atten_weights)\n",
    "        # 选择第0个位置的向量作为句向量\n",
    "        first_token_tensor = sequence_output[:, 0]\n",
    "        # 输出层\n",
    "        pooled_output = self.dense(first_token_tensor)\n",
    "        pooled_output = self.activation(pooled_output)\n",
    "        # 句子级别的输出经过分类器\n",
    "        logits = self.classifier(pooled_output)\n",
    "        return logits\n",
    "\n",
    "    @property\n",
    "    def attention_weights(self):\n",
    "        return self._attention_weights"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "在模型构建完成之后，我们使用RunnerV3类来进行模型的训练、评价、预测等过程。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## 8.3.3 模型训练\n",
    "\n",
    "模型的训练配置的设置，包括一些超参数、优化器、损失函数等等，训练过程：模型的训练从Dataloader中取数据进行前向反向训练，每隔100个step输出一次日志，每隔500个step在验证集合上计算一次准确率。训练3个回合，并保存在验证集上最佳准确率的模型。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Train] epoch: 0/3, step: 0/22386, loss: 1.41052\n",
      "[Train] epoch: 0/3, step: 100/22386, loss: 0.59608\n",
      "[Train] epoch: 0/3, step: 200/22386, loss: 0.67516\n",
      "[Train] epoch: 0/3, step: 300/22386, loss: 0.57150\n",
      "[Train] epoch: 0/3, step: 400/22386, loss: 0.63550\n",
      "[Train] epoch: 0/3, step: 500/22386, loss: 0.61048\n",
      "[Evaluate]  dev score: 0.53647, dev loss: 0.72411\n",
      "[Evaluate] best accuracy performence has been updated: 0.00000 --> 0.53647\n",
      "[Train] epoch: 0/3, step: 600/22386, loss: 0.56387\n",
      "[Train] epoch: 0/3, step: 700/22386, loss: 0.61008\n",
      "[Train] epoch: 0/3, step: 800/22386, loss: 0.58331\n",
      "[Train] epoch: 0/3, step: 900/22386, loss: 0.64518\n",
      "[Train] epoch: 0/3, step: 1000/22386, loss: 0.60527\n",
      "[Evaluate]  dev score: 0.54760, dev loss: 0.73040\n",
      "[Evaluate] best accuracy performence has been updated: 0.53647 --> 0.54760\n",
      "[Train] epoch: 0/3, step: 1100/22386, loss: 0.58656\n",
      "[Train] epoch: 0/3, step: 1200/22386, loss: 0.84857\n",
      "[Train] epoch: 0/3, step: 1300/22386, loss: 0.62063\n",
      "[Train] epoch: 0/3, step: 1400/22386, loss: 0.53945\n",
      "[Train] epoch: 0/3, step: 1500/22386, loss: 0.75425\n",
      "[Evaluate]  dev score: 0.54692, dev loss: 0.74932\n",
      "[Train] epoch: 0/3, step: 1600/22386, loss: 0.50026\n",
      "[Train] epoch: 0/3, step: 1700/22386, loss: 0.60371\n",
      "[Train] epoch: 0/3, step: 1800/22386, loss: 0.66604\n",
      "[Train] epoch: 0/3, step: 1900/22386, loss: 0.45103\n",
      "[Train] epoch: 0/3, step: 2000/22386, loss: 0.54679\n",
      "[Evaluate]  dev score: 0.58282, dev loss: 0.72771\n",
      "[Evaluate] best accuracy performence has been updated: 0.54760 --> 0.58282\n",
      "[Train] epoch: 0/3, step: 2100/22386, loss: 0.63433\n",
      "[Train] epoch: 0/3, step: 2200/22386, loss: 0.52686\n",
      "[Train] epoch: 0/3, step: 2300/22386, loss: 0.37981\n",
      "[Train] epoch: 0/3, step: 2400/22386, loss: 0.55723\n",
      "[Train] epoch: 0/3, step: 2500/22386, loss: 0.58996\n",
      "[Evaluate]  dev score: 0.57964, dev loss: 0.72756\n",
      "[Train] epoch: 0/3, step: 2600/22386, loss: 0.53764\n",
      "[Train] epoch: 0/3, step: 2700/22386, loss: 0.47165\n",
      "[Train] epoch: 0/3, step: 2800/22386, loss: 0.77164\n",
      "[Train] epoch: 0/3, step: 2900/22386, loss: 0.52581\n",
      "[Train] epoch: 0/3, step: 3000/22386, loss: 0.63991\n",
      "[Evaluate]  dev score: 0.59009, dev loss: 0.72667\n",
      "[Evaluate] best accuracy performence has been updated: 0.58282 --> 0.59009\n",
      "[Train] epoch: 0/3, step: 3100/22386, loss: 0.51587\n",
      "[Train] epoch: 0/3, step: 3200/22386, loss: 0.53717\n",
      "[Train] epoch: 0/3, step: 3300/22386, loss: 0.43860\n",
      "[Train] epoch: 0/3, step: 3400/22386, loss: 0.42106\n",
      "[Train] epoch: 0/3, step: 3500/22386, loss: 0.51509\n",
      "[Evaluate]  dev score: 0.60327, dev loss: 0.69725\n",
      "[Evaluate] best accuracy performence has been updated: 0.59009 --> 0.60327\n",
      "[Train] epoch: 0/3, step: 3600/22386, loss: 0.40432\n",
      "[Train] epoch: 0/3, step: 3700/22386, loss: 0.55271\n",
      "[Train] epoch: 0/3, step: 3800/22386, loss: 0.47953\n",
      "[Train] epoch: 0/3, step: 3900/22386, loss: 0.54553\n",
      "[Train] epoch: 0/3, step: 4000/22386, loss: 0.45967\n",
      "[Evaluate]  dev score: 0.60850, dev loss: 0.70727\n",
      "[Evaluate] best accuracy performence has been updated: 0.60327 --> 0.60850\n",
      "[Train] epoch: 0/3, step: 4100/22386, loss: 0.54031\n",
      "[Train] epoch: 0/3, step: 4200/22386, loss: 0.50157\n",
      "[Train] epoch: 0/3, step: 4300/22386, loss: 0.55142\n",
      "[Train] epoch: 0/3, step: 4400/22386, loss: 0.36301\n",
      "[Train] epoch: 0/3, step: 4500/22386, loss: 0.55048\n",
      "[Evaluate]  dev score: 0.60850, dev loss: 0.69972\n",
      "[Train] epoch: 0/3, step: 4600/22386, loss: 0.51235\n",
      "[Train] epoch: 0/3, step: 4700/22386, loss: 0.55484\n",
      "[Train] epoch: 0/3, step: 4800/22386, loss: 0.65680\n",
      "[Train] epoch: 0/3, step: 4900/22386, loss: 0.63147\n",
      "[Train] epoch: 0/3, step: 5000/22386, loss: 0.54686\n",
      "[Evaluate]  dev score: 0.60963, dev loss: 0.69487\n",
      "[Evaluate] best accuracy performence has been updated: 0.60850 --> 0.60963\n",
      "[Train] epoch: 0/3, step: 5100/22386, loss: 0.53735\n",
      "[Train] epoch: 0/3, step: 5200/22386, loss: 0.58669\n",
      "[Train] epoch: 0/3, step: 5300/22386, loss: 0.41979\n",
      "[Train] epoch: 0/3, step: 5400/22386, loss: 0.57399\n",
      "[Train] epoch: 0/3, step: 5500/22386, loss: 0.59520\n",
      "[Evaluate]  dev score: 0.60532, dev loss: 0.71227\n",
      "[Train] epoch: 0/3, step: 5600/22386, loss: 0.40031\n",
      "[Train] epoch: 0/3, step: 5700/22386, loss: 0.49304\n",
      "[Train] epoch: 0/3, step: 5800/22386, loss: 0.37622\n",
      "[Train] epoch: 0/3, step: 5900/22386, loss: 0.42626\n",
      "[Train] epoch: 0/3, step: 6000/22386, loss: 0.48639\n",
      "[Evaluate]  dev score: 0.60986, dev loss: 0.66761\n",
      "[Evaluate] best accuracy performence has been updated: 0.60963 --> 0.60986\n",
      "[Train] epoch: 0/3, step: 6100/22386, loss: 0.51809\n",
      "[Train] epoch: 0/3, step: 6200/22386, loss: 0.51233\n",
      "[Train] epoch: 0/3, step: 6300/22386, loss: 0.46538\n",
      "[Train] epoch: 0/3, step: 6400/22386, loss: 0.65757\n",
      "[Train] epoch: 0/3, step: 6500/22386, loss: 0.53427\n",
      "[Evaluate]  dev score: 0.61736, dev loss: 0.67849\n",
      "[Evaluate] best accuracy performence has been updated: 0.60986 --> 0.61736\n",
      "[Train] epoch: 0/3, step: 6600/22386, loss: 0.54285\n",
      "[Train] epoch: 0/3, step: 6700/22386, loss: 0.61371\n",
      "[Train] epoch: 0/3, step: 6800/22386, loss: 0.58966\n",
      "[Train] epoch: 0/3, step: 6900/22386, loss: 0.57622\n",
      "[Train] epoch: 0/3, step: 7000/22386, loss: 0.61285\n",
      "[Evaluate]  dev score: 0.62372, dev loss: 0.67871\n",
      "[Evaluate] best accuracy performence has been updated: 0.61736 --> 0.62372\n",
      "[Train] epoch: 0/3, step: 7100/22386, loss: 0.56967\n",
      "[Train] epoch: 0/3, step: 7200/22386, loss: 0.32193\n",
      "[Train] epoch: 0/3, step: 7300/22386, loss: 0.39166\n",
      "[Train] epoch: 0/3, step: 7400/22386, loss: 0.42550\n",
      "[Train] epoch: 1/3, step: 7500/22386, loss: 0.39407\n",
      "[Evaluate]  dev score: 0.62009, dev loss: 0.67560\n",
      "[Train] epoch: 1/3, step: 7600/22386, loss: 0.77486\n",
      "[Train] epoch: 1/3, step: 7700/22386, loss: 0.28748\n",
      "[Train] epoch: 1/3, step: 7800/22386, loss: 0.48185\n",
      "[Train] epoch: 1/3, step: 7900/22386, loss: 0.66501\n",
      "[Train] epoch: 1/3, step: 8000/22386, loss: 0.55718\n",
      "[Evaluate]  dev score: 0.62327, dev loss: 0.69143\n",
      "[Train] epoch: 1/3, step: 8100/22386, loss: 0.57032\n",
      "[Train] epoch: 1/3, step: 8200/22386, loss: 0.53956\n",
      "[Train] epoch: 1/3, step: 8300/22386, loss: 0.51917\n",
      "[Train] epoch: 1/3, step: 8400/22386, loss: 0.49092\n",
      "[Train] epoch: 1/3, step: 8500/22386, loss: 0.60034\n",
      "[Evaluate]  dev score: 0.60759, dev loss: 0.71115\n",
      "[Train] epoch: 1/3, step: 8600/22386, loss: 0.39623\n",
      "[Train] epoch: 1/3, step: 8700/22386, loss: 0.67836\n",
      "[Train] epoch: 1/3, step: 8800/22386, loss: 0.51281\n",
      "[Train] epoch: 1/3, step: 8900/22386, loss: 0.41115\n",
      "[Train] epoch: 1/3, step: 9000/22386, loss: 0.56200\n",
      "[Evaluate]  dev score: 0.62327, dev loss: 0.69263\n",
      "[Train] epoch: 1/3, step: 9100/22386, loss: 0.59062\n",
      "[Train] epoch: 1/3, step: 9200/22386, loss: 0.42524\n",
      "[Train] epoch: 1/3, step: 9300/22386, loss: 0.49222\n",
      "[Train] epoch: 1/3, step: 9400/22386, loss: 0.40487\n",
      "[Train] epoch: 1/3, step: 9500/22386, loss: 0.50692\n",
      "[Evaluate]  dev score: 0.62304, dev loss: 0.69803\n",
      "[Train] epoch: 1/3, step: 9600/22386, loss: 0.47532\n",
      "[Train] epoch: 1/3, step: 9700/22386, loss: 0.38368\n",
      "[Train] epoch: 1/3, step: 9800/22386, loss: 0.46955\n",
      "[Train] epoch: 1/3, step: 9900/22386, loss: 0.43820\n",
      "[Train] epoch: 1/3, step: 10000/22386, loss: 0.49995\n",
      "[Evaluate]  dev score: 0.62531, dev loss: 0.68928\n",
      "[Evaluate] best accuracy performence has been updated: 0.62372 --> 0.62531\n",
      "[Train] epoch: 1/3, step: 10100/22386, loss: 0.55208\n",
      "[Train] epoch: 1/3, step: 10200/22386, loss: 0.53569\n",
      "[Train] epoch: 1/3, step: 10300/22386, loss: 0.42870\n",
      "[Train] epoch: 1/3, step: 10400/22386, loss: 0.45446\n",
      "[Train] epoch: 1/3, step: 10500/22386, loss: 0.53092\n",
      "[Evaluate]  dev score: 0.63167, dev loss: 0.66650\n",
      "[Evaluate] best accuracy performence has been updated: 0.62531 --> 0.63167\n",
      "[Train] epoch: 1/3, step: 10600/22386, loss: 0.52953\n",
      "[Train] epoch: 1/3, step: 10700/22386, loss: 0.38617\n",
      "[Train] epoch: 1/3, step: 10800/22386, loss: 0.43861\n",
      "[Train] epoch: 1/3, step: 10900/22386, loss: 0.52512\n",
      "[Train] epoch: 1/3, step: 11000/22386, loss: 0.46010\n",
      "[Evaluate]  dev score: 0.61986, dev loss: 0.72143\n",
      "[Train] epoch: 1/3, step: 11100/22386, loss: 0.64948\n",
      "[Train] epoch: 1/3, step: 11200/22386, loss: 0.47895\n",
      "[Train] epoch: 1/3, step: 11300/22386, loss: 0.58008\n",
      "[Train] epoch: 1/3, step: 11400/22386, loss: 0.51018\n",
      "[Train] epoch: 1/3, step: 11500/22386, loss: 0.47164\n",
      "[Evaluate]  dev score: 0.62986, dev loss: 0.69056\n",
      "[Train] epoch: 1/3, step: 11600/22386, loss: 0.59516\n",
      "[Train] epoch: 1/3, step: 11700/22386, loss: 0.73043\n",
      "[Train] epoch: 1/3, step: 11800/22386, loss: 0.56779\n",
      "[Train] epoch: 1/3, step: 11900/22386, loss: 0.58057\n",
      "[Train] epoch: 1/3, step: 12000/22386, loss: 0.47802\n",
      "[Evaluate]  dev score: 0.64281, dev loss: 0.68643\n",
      "[Evaluate] best accuracy performence has been updated: 0.63167 --> 0.64281\n",
      "[Train] epoch: 1/3, step: 12100/22386, loss: 0.34255\n",
      "[Train] epoch: 1/3, step: 12200/22386, loss: 0.40539\n",
      "[Train] epoch: 1/3, step: 12300/22386, loss: 0.34695\n",
      "[Train] epoch: 1/3, step: 12400/22386, loss: 0.44242\n",
      "[Train] epoch: 1/3, step: 12500/22386, loss: 0.41318\n",
      "[Evaluate]  dev score: 0.62736, dev loss: 0.70442\n",
      "[Train] epoch: 1/3, step: 12600/22386, loss: 0.62775\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_204/4023511741.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     44\u001b[0m     \u001b[0mlog_steps\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m100\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     45\u001b[0m     \u001b[0meval_steps\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m500\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 46\u001b[0;31m     \u001b[0msave_path\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0msave_path\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     47\u001b[0m )\n",
      "\u001b[0;32m~/nndl.py\u001b[0m in \u001b[0;36mtrain\u001b[0;34m(self, train_loader, dev_loader, **kwargs)\u001b[0m\n\u001b[1;32m    150\u001b[0m                 \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    151\u001b[0m                 \u001b[0;31m#获取模型预测\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 152\u001b[0;31m                 \u001b[0mlogits\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    153\u001b[0m                 \u001b[0mloss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mloss_fn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlogits\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# 默认求mean\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    154\u001b[0m                 \u001b[0mtotal_loss\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0mloss\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/paddle/fluid/dygraph/layers.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *inputs, **kwargs)\u001b[0m\n\u001b[1;32m    915\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    916\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__call__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 917\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_dygraph_call_func\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    918\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    919\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/paddle/fluid/dygraph/layers.py\u001b[0m in \u001b[0;36m_dygraph_call_func\u001b[0;34m(self, *inputs, **kwargs)\u001b[0m\n\u001b[1;32m    905\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_built\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    906\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 907\u001b[0;31m         \u001b[0moutputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    908\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    909\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mforward_post_hook\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_forward_post_hooks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/tmp/ipykernel_204/3197319976.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, inputs, position_ids, attention_mask)\u001b[0m\n\u001b[1;32m     73\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mencoder_layer\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlayers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     74\u001b[0m             sequence_output, atten_weights = encoder_layer(\n\u001b[0;32m---> 75\u001b[0;31m                 sequence_output, src_mask=attention_mask )\n\u001b[0m\u001b[1;32m     76\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_attention_weights\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0matten_weights\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     77\u001b[0m         \u001b[0;31m# 选择第0个位置的向量作为句向量\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/paddle/fluid/dygraph/layers.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *inputs, **kwargs)\u001b[0m\n\u001b[1;32m    915\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    916\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__call__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 917\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_dygraph_call_func\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    918\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    919\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/paddle/fluid/dygraph/layers.py\u001b[0m in \u001b[0;36m_dygraph_call_func\u001b[0;34m(self, *inputs, **kwargs)\u001b[0m\n\u001b[1;32m    905\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_built\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    906\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 907\u001b[0;31m         \u001b[0moutputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    908\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    909\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mforward_post_hook\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_forward_post_hooks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/tmp/ipykernel_204/3605784758.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, X, src_mask)\u001b[0m\n\u001b[1;32m     36\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msrc_mask\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     37\u001b[0m         \u001b[0;31m# 多头注意力\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 38\u001b[0;31m         \u001b[0mX_atten\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0matten_weights\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmulti_head_attention\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mattn_mask\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0msrc_mask\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     39\u001b[0m         \u001b[0;31m# 加与规范化\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     40\u001b[0m         \u001b[0mX\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maddnorm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX_atten\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/paddle/fluid/dygraph/layers.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *inputs, **kwargs)\u001b[0m\n\u001b[1;32m    915\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    916\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__call__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 917\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_dygraph_call_func\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    918\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    919\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/paddle/fluid/dygraph/layers.py\u001b[0m in \u001b[0;36m_dygraph_call_func\u001b[0;34m(self, *inputs, **kwargs)\u001b[0m\n\u001b[1;32m    905\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_built\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    906\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 907\u001b[0;31m         \u001b[0moutputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    908\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    909\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mforward_post_hook\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_forward_post_hooks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/paddle/nn/layer/transformer.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, query, key, value, attn_mask, cache)\u001b[0m\n\u001b[1;32m    398\u001b[0m         \u001b[0;31m# compute q ,k ,v\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    399\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mcache\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 400\u001b[0;31m             \u001b[0mq\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mk\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mv\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_prepare_qkv\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mquery\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcache\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    401\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    402\u001b[0m             \u001b[0mq\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mk\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mv\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcache\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_prepare_qkv\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mquery\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcache\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/paddle/nn/layer/transformer.py\u001b[0m in \u001b[0;36m_prepare_qkv\u001b[0;34m(self, query, key, value, cache)\u001b[0m\n\u001b[1;32m    232\u001b[0m             \u001b[0mk\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mv\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcache\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcache\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mv\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    233\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 234\u001b[0;31m             \u001b[0mk\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mv\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcompute_kv\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    235\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    236\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcache\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mCache\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/paddle/nn/layer/transformer.py\u001b[0m in \u001b[0;36mcompute_kv\u001b[0;34m(self, key, value)\u001b[0m\n\u001b[1;32m    270\u001b[0m         \u001b[0mk\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtensor\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mshape\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnum_heads\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhead_dim\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    271\u001b[0m         \u001b[0mk\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtensor\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtranspose\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mperm\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 272\u001b[0;31m         \u001b[0mv\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtensor\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mv\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mshape\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnum_heads\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhead_dim\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    273\u001b[0m         \u001b[0mv\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtensor\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtranspose\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mv\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mperm\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    274\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mk\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mv\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/paddle/tensor/manipulation.py\u001b[0m in \u001b[0;36mreshape\u001b[0;34m(x, shape, name)\u001b[0m\n\u001b[1;32m   1999\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2000\u001b[0m     \"\"\"\n\u001b[0;32m-> 2001\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mpaddle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfluid\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlayers\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mshape\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   2002\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2003\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/paddle/fluid/layers/nn.py\u001b[0m in \u001b[0;36mreshape\u001b[0;34m(x, shape, actual_shape, act, inplace, name)\u001b[0m\n\u001b[1;32m   6211\u001b[0m                 \" got '{}.'\".format(type(shape)))\n\u001b[1;32m   6212\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 6213\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mdygraph_utils\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_append_activation_in_dygraph\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mout\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mact\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   6214\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   6215\u001b[0m     check_variable_and_dtype(x, 'x', [\n",
      "\u001b[0;32m<decorator-gen-142>\u001b[0m in \u001b[0;36m_append_activation_in_dygraph\u001b[0;34m(input, act, use_cudnn, use_mkldnn)\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "from nndl import Accuracy, RunnerV3\n",
    "import os \n",
    "import paddle.nn.functional as F\n",
    "\n",
    "paddle.seed(2021)\n",
    "heads_num = 4\n",
    "epochs = 3\n",
    "vocab_size=21128\n",
    "num_classes= 2\n",
    "padding_idx=word2id_dict['[PAD]']\n",
    "# 注意力多头的数目\n",
    "# 交叉熵损失\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "# 评估的时候采用准确率指标\n",
    "metric = Accuracy()\n",
    "# Transformer的分类模型\n",
    "model = Model_Transformer(\n",
    "    vocab_size=vocab_size,\n",
    "    n_block=1,\n",
    "    num_classes=num_classes,\n",
    "    heads_num=heads_num,\n",
    "    padding_idx=padding_idx,\n",
    ")\n",
    "\n",
    "# 排除所有的偏置和LayerNorm的参数\n",
    "decay_params = [\n",
    "    p.name for n, p in model.named_parameters()\n",
    "    if not any(nd in n for nd in [\"bias\", \"norm\"])\n",
    "]\n",
    "\n",
    "# 定义 Optimizer\n",
    "optimizer = paddle.optimizer.AdamW(\n",
    "    learning_rate=5E-5,\n",
    "    parameters=model.parameters(),\n",
    "    weight_decay=0.0,\n",
    "    apply_decay_param_fun=lambda x: x in decay_params)\n",
    "\n",
    "runner = RunnerV3(model, optimizer, criterion, metric)\n",
    "save_path = \"./checkpoint/model_best.pdparams\"\n",
    "runner.train(\n",
    "    train_loader,\n",
    "    dev_loader,\n",
    "    num_epochs=epochs,\n",
    "    log_steps=100,\n",
    "    eval_steps=500,\n",
    "    save_path=save_path,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from nndl import plot\n",
    "plot(runner, 'att-loss-acc3.pdf')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## 8.3.4 模型评价\n",
    "\n",
    "模型评价使用test\\_loader进行评价，并输出准确率。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "model_path = \"checkpoint/model_best.pdparams\"\n",
    "runner.load_model(model_path)\n",
    "accuracy, _ =  runner.evaluate(test_loader)\n",
    "print(f\"Evaluate on test set, Accuracy: {accuracy:.5f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "********\n",
    "叠加多层的Transformer组块，观察对比实验效果。\n",
    "********"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## 8.3.5 模型预测\n",
    "\n",
    "从测试的数据集中取出一条数据，然后用word2id\\_dict进行编码变成ID的形式，然后放到模型里面进行预测输出，代码实现如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "预测的label标签 1\n"
     ]
    }
   ],
   "source": [
    "model_path = \"checkpoint_base/model_best.pdparams\"\n",
    "runner.load_model(model_path)\n",
    "text_a = \"电脑怎么录像？\"\n",
    "text_b = \"如何在计算机上录视频\"\n",
    "# [CLS]转换成id\n",
    "cls_id = word2id_dict[\"[CLS]\"]\n",
    "# [SEP]转换成id\n",
    "sep_id = word2id_dict[\"[SEP]\"]\n",
    "# text_a转换成id的形式\n",
    "input_ids_a = [\n",
    "    word2id_dict[item] if item in word2id_dict else word2id_dict[\"[UNK]\"]\n",
    "    for item in text_a\n",
    "]\n",
    "# text_b转换成id的形式\n",
    "input_ids_b = [\n",
    "    word2id_dict[item] if item in word2id_dict else word2id_dict[\"[UNK]\"]\n",
    "    for item in text_b\n",
    "]\n",
    "# 两个句子拼接成id的形式\n",
    "input_ids = [cls_id]+ input_ids_a + [sep_id] + input_ids_b + [sep_id]\n",
    "# 分段id的形式\n",
    "segment_ids = [0]*(len(input_ids_a)+2)+[1]*(len(input_ids_b)+1)\n",
    "# 转换成Tensor张量\n",
    "input_ids = paddle.to_tensor([input_ids])\n",
    "segment_ids = paddle.to_tensor([segment_ids])\n",
    "inputs = [input_ids, segment_ids]\n",
    "# 模型预测\n",
    "logits = runner.predict(inputs)\n",
    "# 取概率值最大的索引\n",
    "label_id = paddle.argmax(logits, axis=1).numpy()[0]\n",
    "print('预测的label标签 {}'.format(label_id))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "可以看到预测的标签是1，表明这两句话是相似的，这说明预测的结果是正确的。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## 8.3.6  注意力可视化\n",
    "\n",
    "为了验证注意力机制学到了什么，本节把注意力机制的权重提取出来，然后进行可视化分析。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "输入的文本：['CLS', '电', '脑', '怎', '么', '录', '像', '？', 'SEP', '如', '何', '在', '计', '算', '机', '上', '录', '视', '频', 'SEP']\n",
      "输入的id形式：[101, 4510, 5554, 2582, 720, 2497, 1008, 8043, 102, 1963, 862, 1762, 6369, 5050, 3322, 677, 2497, 6228, 7574, 102]\n"
     ]
    }
   ],
   "source": [
    "# 首先加载模型\n",
    "model_path='checkpoint_base/model_best.pdparams'\n",
    "loaded_dict = paddle.load(model_path)\n",
    "model.load_dict(loaded_dict)\n",
    "model.eval()\n",
    "# 输入一条样本\n",
    "text_a = '电脑怎么录像？'\n",
    "text_b = '如何在计算机上录视频'\n",
    "texts = ['CLS']+list(text_a)+['SEP']+list(text_b)+['SEP']\n",
    "# text_a和text_b分别转换成id的形式\n",
    "input_ids_a = [\n",
    "    word2id_dict[item] if item in word2id_dict else word2id_dict[\"[UNK]\"]\n",
    "    for item in text_a\n",
    "]\n",
    "input_ids_b = [\n",
    "    word2id_dict[item] if item in word2id_dict else word2id_dict[\"[UNK]\"]\n",
    "    for item in text_b\n",
    "]\n",
    "# text_a和text_b拼接\n",
    "input_ids = [cls_id]+ input_ids_a + [sep_id] + input_ids_b + [sep_id]\n",
    "# 分段编码的id的形式\n",
    "segment_ids = [0]*(len(input_ids_a)+2)+[1]*(len(input_ids_b)+1)\n",
    "print(\"输入的文本：{}\".format(texts))\n",
    "print(\"输入的id形式：{}\".format(input_ids))\n",
    "# 转换成Tensor\n",
    "input_ids = paddle.to_tensor([input_ids])\n",
    "segment_ids = paddle.to_tensor([segment_ids])\n",
    "inputs = [input_ids, segment_ids]\n",
    "# 评估模式\n",
    "model.eval()\n",
    "# 模型预测\n",
    "with paddle.no_grad():\n",
    "    pooled_output = model(inputs)\n",
    "# 获取多头注意力权重\n",
    "atten_weights = model.attention_weights[0].numpy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "将注意力权重atten\\_weights进行可视化。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 936x936 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 936x936 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 936x936 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 936x936 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from matplotlib.font_manager import FontProperties\n",
    "import pandas as pd\n",
    "\n",
    "data_attention = atten_weights[0]\n",
    "plt.clf()\n",
    "font_size = 25\n",
    "font = FontProperties(fname=\"simhei.ttf\", size=font_size)\n",
    "# 可视化其中的head，总共heads_num 个head\n",
    "for head in range(heads_num):\n",
    "    data = pd.DataFrame(data=data_attention[head], index=texts, columns=texts)\n",
    "    f, ax = plt.subplots(figsize=(13, 13))\n",
    "    # 使用heatmap可视化\n",
    "    sns.heatmap(data, ax=ax, cmap=\"OrRd\", cbar=False)\n",
    "    # y轴旋转270度\n",
    "    label_y = ax.get_yticklabels()\n",
    "    plt.setp(label_y, rotation=270, horizontalalignment=\"right\", fontproperties=font)\n",
    "    # x轴旋转0度\n",
    "    label_x = ax.get_xticklabels()\n",
    "    plt.setp(label_x, rotation=0, horizontalalignment=\"right\", fontproperties=font)\n",
    "    plt.savefig('att-vis3_{}.pdf'.format(head))\n",
    "    plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "上图所示，颜色越深，表示的权重越高，可以看到第一个位置的[CLS]跟“计”，“视”，“像”，“何”的关系比较大。另外第二句话里面的“计”与“视\"跟第一句话里面的“录像\"，“电脑\"等词关系比较大。对于同一个句子内，“视\"和“频\"的关系很大等等。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "********\n",
    "请可视化自注意力头，挖掘出更多更有意思的信息。\n",
    "********"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# 8.4 基于框架API实现文本语义匹配\n",
    "\n",
    "## 8.4.1【框架API】文本语义匹配\n",
    "\n",
    "### 8.4.1.1 模型构建\n",
    "\n",
    "前面的章节使用了自己实现的TransformerBlock来构建文本语义匹配模型，在实际使用过程中不需要自己实现，直接使用框架的API即可，下面我们来实现一下，对比一下结果。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "class Model_Transformer_v1(nn.Layer):\n",
    "    def __init__(\n",
    "        self,\n",
    "        vocab_size,\n",
    "        n_block=1,\n",
    "        hidden_size=768,\n",
    "        heads_num=12,\n",
    "        intermediate_size=3072,\n",
    "        hidden_dropout=0.1,\n",
    "        attention_dropout=0.1,\n",
    "        act_dropout=0,\n",
    "        position_size=512,\n",
    "        num_classes=2,\n",
    "        padding_idx=0,\n",
    "    ):\n",
    "        super(Model_Transformer_v1, self).__init__()\n",
    "        # 词表大小\n",
    "        self.vocab_size = vocab_size\n",
    "        # Transformer的编码器的数目\n",
    "        self.n_block = n_block\n",
    "        # 每个词映射成稠密向量的维度\n",
    "        self.hidden_size = hidden_size\n",
    "        # 多头注意力的个数\n",
    "        self.heads_num = heads_num\n",
    "        # 逐位前馈层的的维度\n",
    "        self.intermediate_size = intermediate_size\n",
    "        # Embedding层的 Dropout\n",
    "        self.hidden_dropout = hidden_dropout\n",
    "        # 多头注意力的dropout的 dropout参数\n",
    "        self.attention_dropout = attention_dropout\n",
    "        # 位置编码的大小 position_size\n",
    "        self.position_size = position_size\n",
    "        # 类别数\n",
    "        self.num_classes = num_classes\n",
    "        # 逐位前馈层的dropout\n",
    "        self.act_dropout = act_dropout\n",
    "        # [PAD]字符的ID\n",
    "        self.padding_idx = padding_idx\n",
    "        # 实例化输入编码，分段编码和位置编码\n",
    "        self.embeddings = TransformerEmbeddings(\n",
    "            self.vocab_size, self.hidden_size, self.hidden_dropout, self.position_size )\n",
    "        # 实例化Transformer的编码器\n",
    "        self.layers = nn.LayerList([])\n",
    "        for i in range(n_block):\n",
    "            # 使用框架API\n",
    "            encoder_layer = nn.TransformerEncoderLayer(hidden_size, \n",
    "                                                    heads_num, \n",
    "                                                    intermediate_size,\n",
    "                                                    dropout=hidden_dropout,\n",
    "                                                    attn_dropout=attention_dropout,\n",
    "                                                    act_dropout=act_dropout)\n",
    "            self.layers.append(encoder_layer)\n",
    "        # 全连接层\n",
    "        self.dense = nn.Linear(hidden_size, hidden_size)\n",
    "        # 双曲正切激活函数\n",
    "        self.activation = nn.Tanh()\n",
    "        # 最后一层分类器\n",
    "        self.classifier = nn.Linear(hidden_size, num_classes)\n",
    "\n",
    "    def forward(self, inputs, position_ids=None, attention_mask=None):\n",
    "        input_ids, segment_ids = inputs\n",
    "        # 构建Mask矩阵，把Pad的位置即input_ids中为0的位置设置为True,非0的位置设置为False\n",
    "        if attention_mask is None:\n",
    "            attention_mask = paddle.unsqueeze(\n",
    "                (input_ids == self.padding_idx).astype(\"float32\") * -1e9, axis=[1, 2] )\n",
    "        # 抽取特征向量\n",
    "        embedding_output = self.embeddings(\n",
    "            input_ids=input_ids, position_ids=position_ids, segment_ids=segment_ids )\n",
    "        sequence_output = embedding_output\n",
    "        self._attention_weights = []\n",
    "        # Transformer的输出和注意力权重的输出\n",
    "        for i, encoder_layer in enumerate(self.layers):\n",
    "            sequence_output = encoder_layer(\n",
    "                sequence_output, src_mask=attention_mask )\n",
    "        # 选择第0个位置的向量作为句向量\n",
    "        first_token_tensor = sequence_output[:, 0]\n",
    "        # 输出层\n",
    "        pooled_output = self.dense(first_token_tensor)\n",
    "        pooled_output = self.activation(pooled_output)\n",
    "        # 句子级别的输出经过分类器\n",
    "        logits = self.classifier(pooled_output)\n",
    "        return logits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### 8.4.1.2 模型训练\n",
    "\n",
    "模型的训练配置的设置，包括一些超参数、优化器、损失函数等等，训练过程：模型的训练从Dataloader中取数据进行前向反向训练，每隔100个step输出一次日志，每隔500个step在验证集合上计算一次准确率。训练3个回合，并保存在验证集上最佳准确率的模型。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "paddle.seed(2021)\n",
    "heads_num = 4\n",
    "epochs = 3\n",
    "vocab_size=21128\n",
    "num_classes= 2\n",
    "# 注意力多头的数目\n",
    "# 交叉熵损失\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "# 评估的时候采用准确率指标\n",
    "metric = Accuracy()\n",
    "# Transformer的分类模型\n",
    "model = Model_Transformer_v1(\n",
    "    vocab_size=vocab_size,\n",
    "    n_block=1,\n",
    "    num_classes=num_classes,\n",
    "    heads_num=heads_num,\n",
    "    padding_idx=padding_idx,\n",
    ")\n",
    "# 排除所有的偏置和LayerNorm的参数\n",
    "decay_params = [\n",
    "    p.name for n, p in model.named_parameters()\n",
    "    if not any(nd in n for nd in [\"bias\", \"norm\"])\n",
    "]\n",
    "# 定义 Optimizer\n",
    "optimizer = paddle.optimizer.AdamW(\n",
    "    learning_rate=5E-5,\n",
    "    parameters=model.parameters(),\n",
    "    weight_decay=0.0,\n",
    "    apply_decay_param_fun=lambda x: x in decay_params)\n",
    "\n",
    "runner = RunnerV3(model, optimizer, criterion, metric)\n",
    "save_path=\"./checkpoint/model_best.pdparams\"\n",
    "runner.train(train_loader, dev_loader, num_epochs=epochs, log_steps=100, eval_steps=500, save_path=save_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### 8.4.1.2 模型评价\n",
    "\n",
    "模型评价使用test\\_loader进行评价，并输出准确率。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "model_path = \"checkpoint/model_best.pdparams\"\n",
    "runner.load_model(model_path)\n",
    "accuracy, _ =  runner.evaluate(test_loader)\n",
    "print(f\"Evaluate on test set, Accuracy: {accuracy:.5f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## 8.4.2 增加Transformer层数的实验\n",
    "\n",
    "### 8.4.2.1 模型训练\n",
    "\n",
    "模型的训练配置的设置，包括一些超参数、优化器、损失函数等等，训练过程：模型的训练从Dataloader中取数据进行前向反向训练，每隔100个step输出一次日志，每隔500个step在验证集合上计算一次准确率。训练3个回合，并保存在验证集上最佳准确率的模型。\n",
    "\n",
    "为了验证增加Transformer的层数的效果，我们把层数设置为2层来实验。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "paddle.seed(2021)\n",
    "heads_num = 4\n",
    "epochs = 3\n",
    "vocab_size=21128\n",
    "num_classes= 2\n",
    "# 注意力多头的数目\n",
    "# 交叉熵损失\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "# 评估的时候采用准确率指标\n",
    "metric = Accuracy()\n",
    "# Transformer的分类模型\n",
    "model = Model_Transformer_v1(\n",
    "    vocab_size=vocab_size,\n",
    "    n_block=2,\n",
    "    num_classes=num_classes,\n",
    "    heads_num=heads_num,\n",
    "    padding_idx=padding_idx,\n",
    ")\n",
    "# 排除所有的偏置和LayerNorm的参数\n",
    "decay_params = [\n",
    "    p.name for n, p in model.named_parameters()\n",
    "    if not any(nd in n for nd in [\"bias\", \"norm\"])\n",
    "]\n",
    "# 定义 Optimizer\n",
    "optimizer = paddle.optimizer.AdamW(\n",
    "    learning_rate=5E-5,\n",
    "    parameters=model.parameters(),\n",
    "    weight_decay=0.0,\n",
    "    apply_decay_param_fun=lambda x: x in decay_params)\n",
    "\n",
    "runner = RunnerV3(model, optimizer, criterion, metric)\n",
    "save_path=\"./checkpoint/model_best.pdparams\"\n",
    "runner.train(train_loader, dev_loader, num_epochs=epochs, log_steps=100, eval_steps=500, save_path=save_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### 8.4.2.2 模型评价\n",
    "\n",
    "模型评价使用test\\_loader进行评价，并输出准确率。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "model_path = \"checkpoint/model_best.pdparams\"\n",
    "runner.load_model(model_path)\n",
    "accuracy, _ =  runner.evaluate(test_loader)\n",
    "print(f\"Evaluate on test set, Accuracy: {accuracy:.5f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "可以看到，增加了一层transformer的编码器了之后，精度变成了0.72733，说明增加Transformer的编码器的层数，能够提升模型的精度。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# 8.5 小结\n",
    "\n",
    "本章介绍注意力机制的基本概念和代码实现。首先在上一章实践的基础上引入注意力机制来改进文本分类的效果，并进一步实现了多头自注意力模型来提高网络能力。\n",
    "\n",
    "在实践部分，我们利用进一步在多头自注意力的基础上，复现了Transformer编码器模型。由于自注意力模型本书无法建模序列中的位置信息，因此Transformer模型引入了位置编码、分段编码等信息。最后，我们用Transformer编码器模型完成一个文本语义匹配任务。"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "py35-paddle1.2.0"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
